Finding the Most Dangerous Road in Maryland

Andrew McNamara

There are many roads here in Maryland witha reputation for being dangerous. For example, here in College Park, Route One has something of a reputation for being dangerous.
For this project I wanted to evaluate which roads in Maryland are actually the most dangerous and see if I could get some insights about why this may be the case. I found a dataset on Maryland's opendata of all crashes in Maryland since 2015. I downloaded it locally since opendata.maryland.gov goes down for maintenence not infrequently, but attatched is a link to where I got the dataset: https://opendata.maryland.gov/Public-Safety/Maryland-Statewide-Vehicle-Crashes/65du-s3qu.

Collection and Curation¶

In [95]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import statsmodels.api as sm
import statsmodels.formula.api as smf
import sklearn
import folium
from datetime import datetime
crashes = pd.read_csv(r'Maryland_Statewide_Vehicle_Crashes.csv')

    

/tmp/ipykernel_78/2716668262.py:10: DtypeWarning: Columns (33,45) have mixed types. Specify dtype option on import or set low_memory=False.
  crashes = pd.read_csv(r'Maryland_Statewide_Vehicle_Crashes.csv')

The dataset was large to a point where my computer was struggling, so since I'm looking to evaluate Route One in context of other roads in Maryland, I only looked at data which had named roads, as well as restricting the years being looked at to only 2021 and 2022. I then took out some road names that weren't appropriate, such as 'ENT TO BUSINESS' or 'NO NAME'. This was to ensure I was only looking at roads that were truly roads and not just some catch all referring to multiple locations. I also removed all crashes without latitude and longitude since I'm looking to map the data.

In [96]:
#crashes = crashes[crashes['COUNTY_DESC'] =='Prince George\'s' ]
crashes = crashes[pd.notnull(crashes['REFERENCE_ROAD_NAME'])]
crashes = crashes[pd.notnull(crashes['LATITUDE'])]
crashes = crashes[pd.notnull(crashes['LONGITUDE'])]
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'ENT TO BUSINESS']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'NO NAME']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'BEGIN BRIDGE']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'CROSSOVER']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'END BRIDGE']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'ROAD END']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'ENT TO SHOPPING CENTER']

crashes = crashes[~crashes['REFERENCE_ROAD_NAME'].str.contains('EXIT')]
display(crashes)

crashes['datetime'] = crashes['ACC_DATE'].astype(str)+crashes['ACC_TIME'].astype(str)
crashes['datetime'] = crashes['datetime'].apply(lambda x: datetime.strptime(x,"%Y%m%d%H:%M:%S"))
print(len(crashes['REFERENCE_ROAD_NAME'].unique()))
YEAR QUARTER LIGHT_DESC LIGHT_CODE COUNTY_DESC COUNTY_NO MUNI_DESC MUNI_CODE JUNCTION_DESC JUNCTION_CODE ... FEET_MILES_FLAG_DESC FEET_MILES_FLAG DISTANCE_DIR_FLAG REFERENCE_NO REFERENCE_TYPE_CODE REFERENCE_SUFFIX REFERENCE_ROAD_NAME LATITUDE LONGITUDE LOCATION
5 2020 Q2 NaN 6.02 Baltimore City 24.0 NaN NaN Non Intersection 1.0 ... Miles M N NaN NaN NaN NORTH AVE 39.311025 -76.616429 POINT (-76.616429453205 39.311024794431)
7 2022 Q2 NaN 6.02 Baltimore 3.0 NaN 0.0 Intersection Related 3.0 ... Feet F S 0.0 UU NaN QUIET STREAM CT 39.463704 -76.608660 POINT (-76.608659683333 39.46370405)
11 2022 Q2 Daylight 1.00 Cecil 7.0 NaN 0.0 NaN 88.0 ... Miles M N 273.0 MD NaN TELEGRAPH RD 39.699010 -75.814360 POINT (-75.814360383333 39.6990097)
17 2021 Q4 Daylight 1.00 Baltimore 3.0 NaN NaN Not Applicable 0.0 ... Feet F N NaN NaN NaN EASTERN BLVD 39.322488 -76.456602 POINT (-76.456602128426 39.32248773136)
24 2021 Q4 Dark Lights On 3.00 Baltimore 3.0 NaN 0.0 Intersection 2.0 ... Feet F N 3033.0 CO NaN LINDEN AVE 39.250671 -76.693456 POINT (-76.693456366667 39.25067135)
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
848799 2022 Q3 Daylight 1.00 Anne Arundel 2.0 NaN 0.0 Not Applicable 0.0 ... Miles M E 607.0 CO NaN OLD STAGE RD 39.158164 -76.628893 POINT (-76.62889296443 39.158163996637)
848800 2022 Q3 Daylight 1.00 Baltimore 3.0 NaN 0.0 NaN 88.0 ... Feet F N 1300.0 CO NaN REGESTER AVE 39.378626 -76.608568 POINT (-76.608567616667 39.378625966667)
848801 2022 Q3 Daylight 1.00 Baltimore 3.0 NaN 0.0 Not Applicable 0.0 ... Feet F W 4095.0 CO NaN EBENEZER RD 39.387539 -76.418305 POINT (-76.418304879322 39.387539278395)
848802 2022 Q3 Daylight 1.00 Anne Arundel 2.0 NaN 0.0 Non Intersection 1.0 ... Feet F N 12.0 SR NaN OCEANIC DR 39.019090 -76.403650 POINT (-76.40365 39.01909)
848803 2022 Q3 Dark Lights On 3.00 Baltimore 3.0 NaN 0.0 Non Intersection 1.0 ... Feet F E 2189.0 CO NaN PARMELEE RD 39.367800 -76.762110 POINT (-76.76211 39.3678)

732391 rows × 55 columns

78893

Exploration¶

I started out with some basic data exploration. I got the number of crashes for each road documented. I then narrowed down to the 100 most dangerous roads in Maryland as defined by number of crashes. By this metric, Route 1 is the tenth most dangerous road in Maryland from 2015 to 2022. This metric is admittedly flawed, since it doesn't take into account road length or capacity or anything of the sort, but for exploration, seeing where the most crashes take place by sheer number is useful.

In [97]:
roadData = crashes['REFERENCE_ROAD_NAME'].value_counts()
roadData = pd.DataFrame({'road':roadData.index,'crashes':roadData.values})
roadData = roadData.head(100)
display(roadData)
display(roadData[roadData['road']=='BALTIMORE AVE'])
road crashes
0 BALTO BELTWAY 3111
1 ANNAPOLIS RD 2518
2 CAPITAL BELTWAY 2150
3 CONNECTICUT AVE 2130
4 BALTIMORE WASHINGTON PKWY 2116
... ... ...
95 MARTIN LUTHER KING JR BLVD 531
96 DULANEY VALLEY RD 528
97 NORTHWEST EXPRESSWAY 528
98 GOOD LUCK RD 524
99 WHITE MARSH BLVD 517

100 rows × 2 columns

road crashes
9 BALTIMORE AVE 1815

Hypothesis testing on number of crashes¶

To figure out if the number of crashes on any given road is significantly different from the average number of crashes on the 100 most crashed on roads, I did a Z-test, since the sample size is large. I found that Route One does not have significantly more crashes than any of the other top 100 roads. Only the top 6 most dangerous roads have crashes significantly different from the mean.

In [98]:
import scipy.stats
roadData['z-score'] = roadData['crashes'].apply(lambda x:(roadData['crashes'].mean()-x)/roadData['crashes'].std()) 
roadData['p-value'] = roadData['z-score'].apply(lambda x: scipy.stats.norm.sf(abs(x))*2)
roadData['Significant'] = roadData['p-value'].apply(lambda x: x<.05)
display(roadData.head(10))
road crashes z-score p-value Significant
0 BALTO BELTWAY 3111 -4.104533 0.000041 True
1 ANNAPOLIS RD 2518 -2.938238 0.003301 True
2 CAPITAL BELTWAY 2150 -2.214466 0.026797 True
3 CONNECTICUT AVE 2130 -2.175131 0.029620 True
4 BALTIMORE WASHINGTON PKWY 2116 -2.147596 0.031746 True
5 PENNSYLVANIA AVE 2115 -2.145629 0.031903 True
6 GEORGIA AVE 1987 -1.893882 0.058241 False
7 LIBERTY RD 1906 -1.734574 0.082816 False
8 CENTRAL AVE 1823 -1.571332 0.116106 False
9 BALTIMORE AVE 1815 -1.555598 0.119804 False

Now that I have the 100 most dangerous roads in Marlyand by sheer number of crashes, I want to go back to the original dataset to figure out if I can learn about why these roads are so dangerous. To do this, I took my dataset and removed all entries that didn't take place on my list of the top 100 most dangerous roads.

In [99]:
roads = roadData['road'].tolist()
crashes = crashes[crashes['REFERENCE_ROAD_NAME'].isin(roads)]
display(crashes)
YEAR QUARTER LIGHT_DESC LIGHT_CODE COUNTY_DESC COUNTY_NO MUNI_DESC MUNI_CODE JUNCTION_DESC JUNCTION_CODE ... FEET_MILES_FLAG DISTANCE_DIR_FLAG REFERENCE_NO REFERENCE_TYPE_CODE REFERENCE_SUFFIX REFERENCE_ROAD_NAME LATITUDE LONGITUDE LOCATION datetime
5 2020 Q2 NaN 6.02 Baltimore City 24.0 NaN NaN Non Intersection 1.0 ... M N NaN NaN NaN NORTH AVE 39.311025 -76.616429 POINT (-76.616429453205 39.311024794431) 2020-04-30 06:39:00
17 2021 Q4 Daylight 1.00 Baltimore 3.0 NaN NaN Not Applicable 0.0 ... F N NaN NaN NaN EASTERN BLVD 39.322488 -76.456602 POINT (-76.456602128426 39.32248773136) 2021-12-01 16:00:00
28 2021 Q4 Daylight 1.00 Baltimore City 24.0 NaN 999.0 Non Intersection 1.0 ... U N 40.0 US NaN EDMONDSON AVE 39.316242 -76.600602 POINT (-76.600602337322 39.31624205) 2021-11-01 08:00:00
31 2021 Q4 Daylight 1.00 Baltimore 3.0 NaN 0.0 Intersection 2.0 ... F N 1.0 US NaN BELAIR RD 39.383422 -76.499001 POINT (-76.499001276878 39.383421935655) 2021-10-02 15:19:00
100 2021 Q3 Daylight 1.00 Baltimore City 24.0 NaN 999.0 Intersection 2.0 ... F N 648.0 MD E ANNAPOLIS RD 39.283102 -76.646653 POINT (-76.646652592591 39.283101915293) 2021-08-07 07:42:00
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
848755 2022 Q3 NaN 5.02 Prince George's 16.0 NaN 0.0 Non Intersection 1.0 ... F S 5.0 MD NaN BRANCH AVE 38.840298 -76.873562 POINT (-76.873561666667 38.840298333333) 2022-07-09 05:14:00
848756 2022 Q3 Dark No Lights 4.00 Baltimore 3.0 NaN 0.0 Non Intersection 1.0 ... M S 122.0 MD NaN SECURITY BLVD 39.375950 -76.722297 POINT (-76.722296666667 39.37595) 2022-09-23 18:31:00
848765 2022 Q3 Daylight 1.00 Baltimore 3.0 NaN 0.0 Intersection 2.0 ... F N 144.0 MD NaN FREDERICK RD 39.244980 -76.663258 POINT (-76.66325815 39.244980016667) 2022-07-27 12:55:00
848774 2022 Q3 Daylight 1.00 Carroll 6.0 NaN 0.0 Intersection 2.0 ... F N 26.0 MD NaN LIBERTY RD 39.457587 -77.087513 POINT (-77.087512866667 39.457587416667) 2022-07-21 16:45:00
848782 2022 Q3 Daylight 1.00 Prince George's 16.0 NaN 0.0 Non Intersection 1.0 ... F W 295.0 MD NaN BALTIMORE WASHINGTON PKWY 38.918249 -76.940636 POINT (-76.940636 38.918249) 2022-07-03 17:33:00

102406 rows × 56 columns

I mapped all of the crashes from the top ten most crashed on roads on Maryland in order to see if this could provide us any insight about where the most crashes occur. After limiting the crash data to only those belonging to the top ten roads, I assigned a unique color to each road to allow us to differentiate between them more easily.

In [100]:
map_osm = folium.Map(location=[39.0458, -76.6413], zoom_start=9)
roads = roadData['road'].head(10)
top10roads = crashes[crashes['REFERENCE_ROAD_NAME'].isin(roads)]
colors = {'ANNAPOLIS RD':'#E74C3C','LIBERTY RD':'#3498DB','BALTO BELTWAY':'#1ABC9C',
          'BALTIMORE AVE':'#000000','CENTRAL AVE':'#F4D03F','CAPITAL BELTWAY':'#E67E22','CONNECTICUT AVE':'#F0F3F4',
         'GEORGIA AVE':'#909497','BALTIMORE WASHINGTON PKWY':'#186A3B','PENNSYLVANIA AVE':'#FFFFFF'}
for index,crash in top10roads.iterrows():
    folium.Circle(location=[crash["LATITUDE"], crash["LONGITUDE"]],fill=True,opacity=0.8,
                  color=colors[crash['REFERENCE_ROAD_NAME']]).add_to(map_osm)
map_osm
Out[100]:
Make this Notebook Trusted to load map: File -> Trust Notebook

We can see some interesting things. For one, Some roads only have crashes intermittently, such as Liberty Road, which has many spots with only intermittent crashes, but then has some spots with many more crashes clustered together, such as near Frederick and Eldensburg
The same is true with Baltimore Avenue, where we can see clusters near College Park and DC, as well as Laurel.
Where we can see that change is in a road like the Baltimore Beltway, where the crash density is more or less consistent all the way aroung.
The most likely reason for this is because of population density. When roads like Liberty Road are near towns, there are more crashes. A road like the Beltway is always right in the middle of a large population, meaning that crashes are more consistent throughout.

Figuring out crashes per mile¶

Now that we've done this, we should get back to the fact not all of these roads are the same size. If we get the lengths of these roads, we should be able to divide number of crashes by length to get crashes per mile and essentially standardize the crash counts, allowing us to compare these roads on equal footing. In order to do this, I got the length of roads manually and added each in since I couldn't find a good dataset of road lengths in Maryland that could be easily joined on.

In [ ]:
roadData['length'] = 0
roadData.index = roadData['road']
display(roadData.head(40))
road crashes z-score p-value Significant length crashes per mile crashes per mile t crashes per mile p
road
WASHINGTON BLVD WASHINGTON BLVD 1338 -0.617448 0.536939 False 0 341.326531 2.913869 0.004452
BELAIR RD BELAIR RD 1604 -1.140609 0.254033 False 0 232.463768 1.582248 0.065048
CONNECTICUT AVE CONNECTICUT AVE 2130 -2.175131 0.029620 True 0 193.636364 1.107307 0.140992
CRAIN HWY CRAIN HWY 1811 -1.547731 0.121687 False 0 189.435146 1.055917 0.152124
KENILWORTH AVE KENILWORTH AVE 1426 -0.790524 0.429222 False 0 151.702128 0.594363 0.279640
POWDER MILL RD POWDER MILL RD 1466 -0.869195 0.384741 False 0 140.556088 0.458024 0.326065
REISTERSTOWN RD REISTERSTOWN RD 1719 -1.366788 0.171692 False 0 89.718163 -0.163831 0.435797
ANNAPOLIS RD ANNAPOLIS RD 2518 -2.938238 0.003301 True 0 83.405101 -0.241053 0.406048
GEORGIA AVE GEORGIA AVE 1987 -1.893882 0.058241 False 0 82.005778 -0.258170 0.399526
CENTRAL AVE CENTRAL AVE 1823 -1.571332 0.116106 False 0 73.007609 -0.368237 0.358384
BALTIMORE WASHINGTON PKWY BALTIMORE WASHINGTON PKWY 2116 -2.147596 0.031746 True 0 65.067651 -0.465359 0.323482
FREDERICK RD FREDERICK RD 1634 -1.199612 0.230290 False 0 65.047771 -0.465602 0.323397
BALTO BELTWAY BALTO BELTWAY 3111 -4.104533 0.000041 True 0 60.454722 -0.521785 0.303925
PENNSYLVANIA AVE PENNSYLVANIA AVE 2115 -2.145629 0.031903 True 0 60.239248 -0.524421 0.303025
CAPITAL BELTWAY CAPITAL BELTWAY 2150 -2.214466 0.026797 True 0 51.558753 -0.630601 0.267907
LIVINGSTON RD LIVINGSTON RD 1341 -0.623348 0.533056 False 0 50.224719 -0.646919 0.262712
YORK RD YORK RD 1397 -0.733488 0.463261 False 0 46.473719 -0.692802 0.248408
LIBERTY RD LIBERTY RD 1906 -1.734574 0.082816 False 0 43.219955 -0.732602 0.236371
BALTIMORE AVE BALTIMORE AVE 1815 -1.555598 0.119804 False 0 22.446203 -0.986709 0.168092
BRANCH AVE BRANCH AVE 1505 -0.945899 0.344200 False 0 20.244821 -1.013637 0.161746
JOHN HANSON HWY JOHN HANSON HWY 1573 -1.079639 0.280303 False 0 10.509788 -1.132717 0.135713
PULASKI HWY PULASKI HWY 1659 -1.248782 0.211745 False 0 7.496272 -1.169578 0.128317
NEW HAMPSHIRE AVE NEW HAMPSHIRE AVE 1316 -0.574179 0.565847 False 0 NaN NaN NaN
BALTO NATIONAL PIKE BALTO NATIONAL PIKE 1305 -0.552545 0.580575 False 0 NaN NaN NaN
HARFORD RD HARFORD RD 1296 -0.534844 0.592758 False 0 NaN NaN NaN
BALTO ANNAPOLIS BLVD BALTO ANNAPOLIS BLVD 1235 -0.414871 0.678237 False 0 NaN NaN NaN
LANDOVER RD LANDOVER RD 1194 -0.334233 0.738204 False 0 NaN NaN NaN
FALLS RD FALLS RD 1174 -0.294898 0.768072 False 0 NaN NaN NaN
WATERLOO RD WATERLOO RD 1168 -0.283097 0.777102 False 0 NaN NaN NaN
GOV RITCHIE HWY GOV RITCHIE HWY 1150 -0.247695 0.804370 False 0 NaN NaN NaN
RITCHIE MARLBORO RD RITCHIE MARLBORO RD 1129 -0.206393 0.836484 False 0 NaN NaN NaN
RIVER RD RIVER RD 1100 -0.149357 0.881272 False 0 NaN NaN NaN
RIDGE RD RIDGE RD 1086 -0.121822 0.903040 False 0 NaN NaN NaN
ROCKVILLE PIKE ROCKVILLE PIKE 1056 -0.062819 0.949911 False 0 NaN NaN NaN
LOCH RAVEN BLVD LOCH RAVEN BLVD 1033 -0.017583 0.985972 False 0 NaN NaN NaN
SECURITY BLVD SECURITY BLVD 993 0.061088 0.951289 False 0 NaN NaN NaN
EAST WEST HWY EAST WEST HWY 992 0.063055 0.949723 False 0 NaN NaN NaN
CHERRY HILL RD CHERRY HILL RD 988 0.070922 0.943460 False 0 NaN NaN NaN
ST BARNABAS RD ST BARNABAS RD 980 0.086656 0.930945 False 0 NaN NaN NaN
GREENSPRING AVE GREENSPRING AVE 964 0.118124 0.905969 False 0 NaN NaN NaN
In [146]:
roadData.at['BALTO BELTWAY','length'] = 51.46 
roadData.at['ANNAPOLIS RD','length'] = 30.19 
roadData.at['CAPITAL BELTWAY','length'] = 41.7
roadData.at['CONNECTICUT AVE','length'] = 20.3
roadData.at['BALTIMORE WASHINGTON PKWY','length'] = 32.52
roadData.at['PENNSYLVANIA AVE','length'] = 35.11
roadData.at['GEORGIA AVE','length'] = 24.23
roadData.at['LIBERTY RD','length'] = 44.10 
roadData.at['CENTRAL AVE','length'] = 24.97
roadData.at['BALTIMORE AVE','length'] = 80.86
roadData.at['CRAIN HWY','length'] = 9.56
roadData.at['REISTERSTOWN RD','length'] = 19.16
roadData.at['PULASKI HWY','length'] = 221.31
roadData.at['FREDERICK RD','length'] = 7.57+17.55
roadData.at['BELAIR RD','length'] = 21.3
roadData.at['JOHN HANSON HWY','length'] = 149.67
roadData.at['BRANCH AVE','length'] =  74.34
roadData.at['POWDER MILL RD','length'] =  10.43
roadData.at['KENILWORTH AVE','length'] =  9.4
roadData.at['YORK RD','length'] =  30.06
roadData.at['LIVINGSTON RD','length'] =  26.7
roadData.at['WASHINGTON BLVD','length'] =81
roadData.at['NEW HAMPSHIRE RD','length']=25.89
roadData.at['BALTO NATIONAL PIKE','length']=221.31
roadData.at['HARFORD RD','length']=18.82
roadData.at['BALTO ANNAPOLIS BLVD','length']=20.91
roadData.at['LANDOVER RD','length']=13.92
roadData.at['FALLS RD','length']=26.89
roadData.at['WATERLOO RD','length']=1.14
roadData.at['GOV RITCHIE HWY','length']= 79.24 
roadData.at['RITCHIE MARLBORO RD','length']= 15.62 
roadData.at['RIVER RD','length']= 15.88
roadData.at['RIDGE RD','length']= 39.17
roadData.at['ROCKVILLE PIKE','length']= 36.75
roadData.at['LOCH RAVEN BLVD','length']= 6.33
roadData.at['SECURITY BLVD','length']= 51.46
roadData.at['EAST WEST HWY','length']= 13.92
roadData.at['CHERRY HILL RD','length']= 16.8
roadData.at['ST BARNABAS RD','length']= 5.64
roadData.at['GREENSPRING AVE','length']= 19.4



def crashpermilecalculator(crashes, miles):
    if miles != 0:
        return crashes / miles
    else: 
        return np.nan
    
roadData['crashes per mile'] = roadData.apply(lambda x: crashpermilecalculator(x.crashes, x.length), axis=1)
roadData.sort_values(by='crashes per mile',ascending=False, inplace=True,)

There are many roads here in Maryland witha reputation for being dangerous. For example, here in College Park, Route One has something of a reputation for being dangerous.
For this project I wanted to evaluate which roads in Maryland are actually the most dangerous and see if I could get some insights about why this may be the case. I found a dataset on Maryland's opendata of all crashes in Maryland since 2015. I downloaded it locally since opendata.maryland.gov goes down for maintenence not infrequently, but attatched is a link to where I got the dataset: https://opendata.maryland.gov/Public-Safety/Maryland-Statewide-Vehicle-Crashes/65du-s3qu.

Hypothesis testing on Crashes per mile¶

Now that we have crashes per mile, we can figure out if any of these roads have a statistically significant difference in their crashes per mile. I used a Z test due to the large sample size of 40. I chose my significance level as .05

In [147]:
cpm_std = roadData.head(40)['crashes per mile'].std()
cpm_mean = roadData.head(40)['crashes per mile'].mean()
def crashpermileTcalculator(crashes):
    if crashes == crashes:
        return (crashes-cpm_mean)/cpm_std
    else: 
        return np.nan
roadData['crashes per mile t'] = roadData['crashes per mile'].apply(crashpermileTcalculator)
roadData['crashes per mile p'] = roadData['crashes per mile t'].apply(lambda x: scipy.stats.norm.sf(abs(x))*2)


display(roadData.head(20))
road crashes z-score p-value Significant length crashes per mile crashes per mile t crashes per mile p
road
CRAIN HWY CRAIN HWY 1811.0 -1.547731 0.121687 False 9.56 189.435146 2.616510 0.008883
ST BARNABAS RD ST BARNABAS RD 980.0 0.086656 0.930945 False 5.64 173.758865 2.307664 0.021018
LOCH RAVEN BLVD LOCH RAVEN BLVD 1033.0 -0.017583 0.985972 False 6.33 163.191153 2.099465 0.035776
KENILWORTH AVE KENILWORTH AVE 1426.0 -0.790524 0.429222 False 9.40 151.702128 1.873114 0.061053
POWDER MILL RD POWDER MILL RD 1466.0 -0.869195 0.384741 False 10.43 140.556088 1.653520 0.098225
CONNECTICUT AVE CONNECTICUT AVE 2130.0 -2.175131 0.029620 True 20.30 104.926108 0.951556 0.341322
REISTERSTOWN RD REISTERSTOWN RD 1719.0 -1.366788 0.171692 False 19.16 89.718163 0.651937 0.514442
ANNAPOLIS RD ANNAPOLIS RD 2518.0 -2.938238 0.003301 True 30.19 83.405101 0.527561 0.597804
GEORGIA AVE GEORGIA AVE 1987.0 -1.893882 0.058241 False 24.23 82.005778 0.499992 0.617081
BELAIR RD BELAIR RD 1604.0 -1.140609 0.254033 False 21.30 75.305164 0.367980 0.712888
CENTRAL AVE CENTRAL AVE 1823.0 -1.571332 0.116106 False 24.97 73.007609 0.322714 0.746912
RITCHIE MARLBORO RD RITCHIE MARLBORO RD 1129.0 -0.206393 0.836484 False 15.62 72.279129 0.308362 0.757807
EAST WEST HWY EAST WEST HWY 992.0 0.063055 0.949723 False 13.92 71.264368 0.288370 0.773064
RIVER RD RIVER RD 1100.0 -0.149357 0.881272 False 15.88 69.269521 0.249069 0.803308
BALTIMORE WASHINGTON PKWY BALTIMORE WASHINGTON PKWY 2116.0 -2.147596 0.031746 True 32.52 65.067651 0.166285 0.867932
FREDERICK RD FREDERICK RD 1634.0 -1.199612 0.230290 False 25.12 65.047771 0.165894 0.868241
BALTO BELTWAY BALTO BELTWAY 3111.0 -4.104533 0.000041 True 51.46 60.454722 0.075404 0.939893
PENNSYLVANIA AVE PENNSYLVANIA AVE 2115.0 -2.145629 0.031903 True 35.11 60.239248 0.071159 0.943271
CHERRY HILL RD CHERRY HILL RD 988.0 0.070922 0.943460 False 16.80 58.809524 0.042991 0.965709
CAPITAL BELTWAY CAPITAL BELTWAY 2150.0 -2.214466 0.026797 True 41.70 51.558753 -0.099860 0.920456

After doing this, we can see that Route One is only the seventeenth most dangerous road in Maryland. To find out which of these are statistically significant, we calculated t scores and p values for crashes per mile on these roads.
From the p values, we can see that the only outlier was Belair road, The rest are within a 95% confidence interval.

We can now map our top 10 most dangerous roads by crashes per mile

In [151]:
map_osm = folium.Map(location=[39.0458, -76.6413], zoom_start=9)
roads = roadData['road'].head(10)
top10roads = crashes[crashes['REFERENCE_ROAD_NAME'].isin(roads)]
#colors = {'CONNECTICUT AVE':'#E74C3C','BELAIR RD':'#3498DB','CRAIN HWY':'#1ABC9C',
#          'KENILWORTH AVE':'#000000','POWDER MILL RD':'#F4D03F','REISTERSTOWN RD':'#E67E22','ANNAPOLIS RD':'#F0F3F4',
#         'GEORGIA AVE':'#909497','CENTRAL AVE':'#186A3B','BALTIMORE WASHINGTON PKWY':'#FFFFFF'}
for index,crash in top10roads.iterrows():
    folium.Circle(location=[crash["LATITUDE"], crash["LONGITUDE"]],fill=True,opacity=0.8).add_to(map_osm)
"""color=colors[crash['REFERENCE_ROAD_NAME']]"""
map_osm
Out[151]:
Make this Notebook Trusted to load map: File -> Trust Notebook

This yield further insights. We can see that the most dangerous roads tend to be smaller roads neared to population centers. We can see more crashes where roads move near or through major cities like Washington or Baltimore. As well as when they have exits to more major highways like 95.

It's now worth looking into the conditions on these roads to see if we can figure out why they have so many crashes.

In [149]:
roadDataNoZero = roadData[roadData['length']!=0]
bestfit = np.polyfit(roadDataNoZero['length'],roadDataNoZero['crashes'], 1)
fig, ax = plt.subplots()
ax.plot(roadDataNoZero['length'],roadDataNoZero['crashes'],'o')
ax.plot(roadDataNoZero['length'],list(map((lambda x: x*bestfit[0] + bestfit[1]),roadDataNoZero['length'])))
Out[149]:
[<matplotlib.lines.Line2D at 0xffff23526820>]
In [106]:
display(top10roads)
YEAR QUARTER LIGHT_DESC LIGHT_CODE COUNTY_DESC COUNTY_NO MUNI_DESC MUNI_CODE JUNCTION_DESC JUNCTION_CODE ... FEET_MILES_FLAG DISTANCE_DIR_FLAG REFERENCE_NO REFERENCE_TYPE_CODE REFERENCE_SUFFIX REFERENCE_ROAD_NAME LATITUDE LONGITUDE LOCATION datetime
31 2021 Q4 Daylight 1.0 Baltimore 3.0 NaN 0.0 Intersection 2.0 ... F N 1.0 US NaN BELAIR RD 39.383422 -76.499001 POINT (-76.499001276878 39.383421935655) 2021-10-02 15:19:00
100 2021 Q3 Daylight 1.0 Baltimore City 24.0 NaN 999.0 Intersection 2.0 ... F N 648.0 MD E ANNAPOLIS RD 39.283102 -76.646653 POINT (-76.646652592591 39.283101915293) 2021-08-07 07:42:00
1026 2021 Q1 Daylight 1.0 Prince George's 16.0 NaN 0.0 Intersection 2.0 ... F S 450.0 MD NaN ANNAPOLIS RD 38.941544 -76.902942 POINT (-76.902942308593 38.941544413224) 2021-01-15 14:27:00
1194 2022 Q2 Daylight 1.0 Baltimore 3.0 NaN NaN Not Applicable 0.0 ... U W NaN NaN NaN BELAIR RD 39.363208 -76.518258 POINT (-76.518258183333 39.363207716667) 2022-04-22 15:00:00
1362 2021 Q1 Dark Lights On 3.0 Prince George's 16.0 NaN 0.0 Non Intersection 1.0 ... F S 212.0 MD NaN POWDER MILL RD 39.043303 -76.940396 POINT (-76.940396215191 39.043303419598) 2021-02-09 21:10:00
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
848675 2022 Q3 Daylight 1.0 Caroline 5.0 NaN 0.0 Intersection 2.0 ... F S 86.0 CO NaN CENTRAL AVE 39.115075 -75.781911 POINT (-75.78191126209 39.115075101549) 2022-08-11 15:33:00
848682 2022 Q3 Dark No Lights 4.0 Anne Arundel 2.0 NaN 0.0 Not Applicable 0.0 ... F N 295.0 MD NaN BALTIMORE WASHINGTON PKWY 39.210777 -76.649600 POINT (-76.64959965 39.210777083333) 2022-09-06 05:45:00
848710 2022 Q3 Dark Lights On 3.0 Baltimore 3.0 NaN 0.0 Non Intersection 1.0 ... M S 140.0 MD NaN REISTERSTOWN RD 39.380725 -76.740182 POINT (-76.740181666667 39.380725) 2022-09-19 23:49:00
848743 2022 Q3 Daylight 1.0 Charles 8.0 NaN 88.0 Intersection 2.0 ... F E 301.0 US NaN CRAIN HWY 38.542957 -76.978532 POINT (-76.97853217985 38.542956983736) 2022-08-08 12:15:00
848782 2022 Q3 Daylight 1.0 Prince George's 16.0 NaN 0.0 Non Intersection 1.0 ... F W 295.0 MD NaN BALTIMORE WASHINGTON PKWY 38.918249 -76.940636 POINT (-76.940636 38.918249) 2022-07-03 17:33:00

18600 rows × 56 columns

In [107]:
print(top10roads.columns)
display(top10roads['ACC_TIME'])

Index(['YEAR', 'QUARTER', 'LIGHT_DESC', 'LIGHT_CODE', 'COUNTY_DESC',
       'COUNTY_NO', 'MUNI_DESC', 'MUNI_CODE', 'JUNCTION_DESC', 'JUNCTION_CODE',
       'COLLISION_TYPE_DESC', 'COLLISION_TYPE_CODE', 'SURF_COND_DESC',
       'SURF_COND_CODE', 'LANE_CODE', 'RD_COND_DESC', 'RD_COND_CODE',
       'RD_DIV_DESC', 'RD_DIV_CODE', 'FIX_OBJ_DESC', 'FIX_OBJ_CODE',
       'REPORT_NO', 'REPORT_TYPE', 'WEATHER_DESC', 'WEATHER_CODE', 'ACC_DATE',
       'ACC_TIME', 'LOC_CODE', 'SIGNAL_FLAG_DESC', 'SIGNAL_FLAG',
       'C_M_ZONE_FLAG', 'AGENCY_CODE', 'AREA_CODE', 'HARM_EVENT_DESC1',
       'HARM_EVENT_CODE1', 'HARM_EVENT_DESC2', 'HARM_EVENT_CODE2', 'RTE_NO',
       'ROUTE_TYPE_CODE', 'RTE_SUFFIX', 'LOG_MILE', 'LOGMILE_DIR_FLAG_DESC',
       'LOGMILE_DIR_FLAG', 'MAINROAD_NAME', 'DISTANCE', 'FEET_MILES_FLAG_DESC',
       'FEET_MILES_FLAG', 'DISTANCE_DIR_FLAG', 'REFERENCE_NO',
       'REFERENCE_TYPE_CODE', 'REFERENCE_SUFFIX', 'REFERENCE_ROAD_NAME',
       'LATITUDE', 'LONGITUDE', 'LOCATION', 'datetime'],
      dtype='object')

31        15:19:00
100       07:42:00
1026      14:27:00
1194      15:00:00
1362      21:10:00
            ...   
848675    15:33:00
848682    05:45:00
848710    23:49:00
848743    12:15:00
848782    17:33:00
Name: ACC_TIME, Length: 18600, dtype: object

Conclusions¶

From this we can draw a few conclusions. The most dangerous roads in Maryland are the roads closest to population centers that are small, low capacity roads. Belair road in particular has significantly more crashes per mile than other roads. Route One, when put into context does not have significantly more crashes than one would expect.

In [ ]: